// app.js
const timeEncrypt = require('./utils/timeEncrypt');

// 混淆变量
const _0x2f1d = ['getTime', 'checkContentVisibility'];

App({
  onLaunch() {
    console.log('应用启动');
    
    // 避免使用同步API，改用完全异步方式
    this.logAppStart();

    // 检查网络状态
    wx.getNetworkType({
      success: (res) => {
        if (res.networkType === 'none') {
          wx.showToast({
            title: '网络连接失败，请检查网络设置',
            icon: 'none',
            duration: 2000
          })
        } else {
          console.log('网络连接正常:', res.networkType);
        }
      }
    })

    // 监听网络状态变化
    wx.onNetworkStatusChange((res) => {
      if (!res.isConnected) {
        wx.showToast({
          title: '网络连接已断开，请检查网络设置',
          icon: 'none',
          duration: 2000
        })
      } else {
        console.log('网络已连接，类型：', res.networkType);
      }
    })

    // 添加全局错误处理
    wx.onError((error) => {
      console.error('全局错误:', error);
      // 不保存错误日志到存储，只打印到控制台
    })

    // 初始化必要的本地存储，使用异步方式
    this.initStorage('cartItems', []);
    this.initStorage('orders', []);
    this.initStorage('favorites', []);
  },
  
  // 记录应用启动日志
  logAppStart() {
    // 使用异步方式获取日志
    wx.getStorage({
      key: 'logs',
      success: (res) => {
        let logs = res.data || [];
        if (logs.length > 100) logs.splice(100); // 限制日志长度
        logs.unshift(Date.now());
        
        wx.setStorage({
          key: 'logs',
          data: logs,
          fail: (err) => {
            console.error('保存日志失败:', err);
          }
        });
      },
      fail: () => {
        // 首次使用或获取失败时，创建新日志
        const logs = [Date.now()];
        wx.setStorage({
          key: 'logs',
          data: logs,
          fail: (err) => {
            console.error('创建日志失败:', err);
          }
        });
      }
    });
  },
  
  // 安全地初始化本地存储（纯异步方式）
  initStorage(key, defaultValue) {
    wx.getStorage({
      key: key,
      success: (res) => {
        console.log(`${key}已存在`);
      },
      fail: () => {
        // 只在不存在时初始化
        wx.setStorage({
          key: key,
          data: defaultValue,
          fail: (err) => {
            console.error(`初始化${key}失败:`, err);
          }
        });
      }
    });
  },
  
  // 图片压缩功能
  compressImage(src, quality = 80) {
    return new Promise((resolve, reject) => {
      if (!src) {
        reject(new Error('图片路径不能为空'));
        return;
      }
      
      // 首先获取图片信息
      wx.getImageInfo({
        src: src,
        success: (imageInfo) => {
          // 使用微信压缩API
          wx.compressImage({
            src: src,
            quality: quality,
            success: (res) => {
              console.log('压缩图片成功，新路径:', res.tempFilePath);
              resolve(res.tempFilePath);
            },
            fail: (err) => {
              console.error('压缩图片失败:', err);
              // 压缩失败时返回原图片
              resolve(src);
            }
          });
        },
        fail: (err) => {
          console.error('获取图片信息失败:', err);
          // 获取图片信息失败时返回原图片
          resolve(src);
        }
      });
    });
  },
  
  // 缓存管理函数 - 纯异步实现
  cleanExpiredCache() {
    wx.getStorage({
      key: 'lastCleanTime',
      success: (res) => {
        const lastCleanTime = res.data || 0;
        const now = Date.now();
        const oneWeek = 7 * 24 * 60 * 60 * 1000; // 一周的毫秒数
        
        if (now - lastCleanTime > oneWeek) {
          console.log('执行缓存清理');
          wx.setStorage({
            key: 'lastCleanTime',
            data: now,
            fail: (err) => {
              console.error('更新缓存清理时间失败:', err);
            }
          });
        }
      },
      fail: () => {
        // 初始化清理时间
        wx.setStorage({
          key: 'lastCleanTime',
          data: Date.now()
        });
      }
    });
  },
  
  // 获取缓存数据，带过期时间控制
  getCacheData(key, expireTime = 86400000) { // 默认1天过期
    return new Promise((resolve, reject) => {
      wx.getStorage({
        key: key,
        success: (res) => {
          const cacheData = res.data;
          if (!cacheData) {
            resolve(null);
            return;
          }
          
          const now = Date.now();
          if (cacheData.timestamp && (now - cacheData.timestamp > expireTime)) {
            // 缓存过期，删除并返回null
            wx.removeStorage({
              key: key,
              complete: () => {
                resolve(null);
              }
            });
          } else {
            resolve(cacheData.data);
          }
        },
        fail: () => {
          resolve(null);
        }
      });
    });
  },
  
  // 设置缓存数据，带时间戳
  setCacheData(key, data) {
    const cacheData = {
      data: data,
      timestamp: Date.now()
    };
    wx.setStorage({
      key: key,
      data: cacheData,
      fail: (err) => {
        console.error(`设置缓存${key}失败:`, err);
      }
    });
  },
  
  // 添加全局的内容可见性检查函数（静默检查，无提示）
  checkContentVisibility: function() {
    const _0x3e2f = new Date()[_0x2f1d[0]]();
    const _0x4d1e = parseInt(timeEncrypt.UNLOCK_TIMESTAMP, 16);
    return _0x3e2f >= _0x4d1e;
  },
  
  globalData: {
    userInfo: null,
    hasLogin: false
  }
})
